#include <vector>
#include <iostream>
#include <algorithm>


int solve_line_thefts(std::vector<int>&v)
{
    // 初始化结果数组
    int n = v.size();
    std::vector<int>dp(n+1);

    // 初始化后的初始化
    dp[0] = v[0];
    dp[1] = std::max(dp[0],v[1]);
    
    // 遍历动态规划
    for (int i = 2;i < n;i++)
    {
        dp[i] = std::max(dp[i-1],dp[i-2]+v[i]);
    }
    return dp[n-1];
}

// 新的且仅此一个问题:偷第一个的同时不能偷最后一个
int solve_ring_thefts(std::vector<int>&v)
{
    // 初始化结果数组
    int n = v.size();
    std::vector<int>dp(n);

    // 不行我认为我现在脑袋有点不好使了
    // 我得睡觉了明天还要起早
}
// 这个是烂尾的函数了


// 其实我已经知道倒数第二个有了，也想过要从第一个到倒数第二个
class Solution
{
    private:
    int solve_line(std::vector<int>&v,int start,int end)
    {
        if (start > end)    return 0;
        int len = end-start+1;
        if (len == 1)  return v[start];
        
        // 
        int prev1 = std::max(v[start],v[start+1]);
        if (len == 2)
        {
            return prev1;
        }

        int prev2 = v[start];
        for (int i = start+2;i <= end;i++)
        {
            int cur = std::max(prev1,prev2+v[i]);
            // 滚动化变量，滚动化是一个很有意思的操作
            prev2 = prev1;
            prev1 = cur;
        }

        // 这里还是需要细节理解一下
        return prev1;
    }

    public:
    int solve_ring(std::vector<int>&v)
    {
        // 首先求长度n,并且返回前4个
        int n = v.size()    ;
        if (n == 0)   return 0;
        if (n == 1)   return v[0];
        if (n == 2)   return std::max(v[0],v[1]);

        // 求出0 - n-1 的动态最大值
        // 再求出1 - n 的动态最大值
        int res1 = solve_line(v,0,n-2);
        int res2 = solve_line(v,1,n-1);

        // 因为其他阶段的最优解根本用不到最后一个数值
        // 返回两次结果的最大值
        return std::max(res1,res2);
    }
};

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);

    int n;
    std::cin>>n;
    std::vector<int>v(n);
    
    for (int i = 0;i < n;i++)
    {
        std::cin>>v[i];
    }

    // 输出结果
    Solution* s = new Solution;
    std::cout<<s->solve_ring(v)<<"\n";

    delete s;
    return 0;
}